package com.kandinfo.isbnmanage.service.impl;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.apache.commons.collections.CollectionUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import com.kandinfo.base.admin.domain.DictData;
import com.kandinfo.base.admin.enumeration.DictType;
import com.kandinfo.base.admin.service.DictDataService;
import com.kandinfo.base.security.SecurityContext;
import com.kandinfo.isbnmanage.domian.IsbnDistribute;
import com.kandinfo.isbnmanage.domian.IsbnInformation;
import com.kandinfo.isbnmanage.domian.IsbnManage;
import com.kandinfo.isbnmanage.enums.IsbnRoleCodeEnum;
import com.kandinfo.isbnmanage.repository.IsbnAutoDistributeRepository;
import com.kandinfo.isbnmanage.repository.IsbnManageRepository;
import com.kandinfo.isbnmanage.service.IsbnAutoDistributeService;
import com.kandinfo.isbnmanage.service.IsbnDistributeService;
import com.kandinfo.isbnmanage.service.IsbnInformationService;
import com.kandinfo.isbnmanage.service.IsbnManageService;



@Service
public class IsbnAutoDistributeServiceImpl implements IsbnAutoDistributeService {
	
	//默认自动分发人
	private final static Long ISBN_ADMIN_USERID = 1L;
	//一次自动分发数量
	private final static int ONCE_AUTO_DISTRIBUTE_COUNT = 5;
	
	@Autowired
	private DictDataService dictDataService;
	
	@Autowired
	private IsbnAutoDistributeRepository isbnAutoDistributeRepository;
	
	@Autowired
	private IsbnDistributeService isbnDistributeService;
	
	@Autowired
	private IsbnManageService isbnManageService;
	
	@Autowired
	private IsbnInformationService isbnInformationService;
	
	@Autowired
	private IsbnManageRepository isbnManageRepository;
	
	/**
	 * 获取isbn角色id
	 * 
	 * @param IsbnRoleCodeEnum
	 * @return
	 */
	private Long getRoleId(IsbnRoleCodeEnum isbnRoleCodeEnum){
		DictData dictData = dictDataService.getByCode(DictType.ISBN, isbnRoleCodeEnum.getCode());
		return dictData == null?null:Long.valueOf(dictData.getValue());
	}
	
	/**
	 * 获取isbn管理员权限id
	 * @return
	 */
	private Long getIsbnManagerRoleId(){
		DictData dictData = dictDataService.getByCode(DictType.ISBN, IsbnRoleCodeEnum.ISBN_MANAGER.getCode());
		return dictData == null?null:Long.valueOf(dictData.getValue());
	}
	
	/**
	 * 获取被自动分发的用户id
	 * 
	 * @param roleId
	 * @param isbnDistributeType
	 * @param isbnManagerRoleId 
	 * @return
	 */
	private Long getAutoUserId(Long roleId,Integer isbnDistributeType, Long isbnManagerRoleId){
		if (isbnDistributeType == null) {
			return null;
		}
		Long userId = isbnAutoDistributeRepository.getNoJobUserId(roleId, isbnDistributeType,isbnManagerRoleId);
		if (userId != null) {
			return userId;
		}
		return isbnAutoDistributeRepository.getHadMinJobUserId(roleId, isbnDistributeType,isbnManagerRoleId);
	}
	
	/**
	 * 获取当前要处理的IsbnManage
	 * 
	 * @param type      isbnDistribute type			
	 * 					0:购书任务       对应refKeyList       isbn_manage id
						1:上传图片并完善信息        对应refKeyList       isbn_information   id
						2,并审核发布    对应refKeyList       isbn_information   id      
	 * @param refKeyList
	 * @return
	 */
	private Map<Long, IsbnManage> getIsbnManageMap(int type, List<Long> refKeyList) {
		Map<Long, IsbnManage> map = new HashMap<Long, IsbnManage>();
		if (CollectionUtils.isEmpty(refKeyList)) {
			return map;
		}
		if (0 == type) {
			//购书
			List<IsbnManage> isbnManageList = isbnManageService.findAll(refKeyList);
			for (IsbnManage isbnManage : isbnManageList) {
				map.put(isbnManage.getId(), isbnManage);
			}
			return map;
		}else if (1 == type || 2 == type ) {
			//ibn信息部分
			List<IsbnManage> isbnManageList = isbnManageRepository.getIsbnManageByInfoId(refKeyList);
			Map<String,IsbnManage> helpMap = new HashMap<String,IsbnManage>();
			for (IsbnManage isbnManage : isbnManageList) {
				helpMap.put(isbnManage.getBarcode(), isbnManage);
			}
			List<IsbnInformation> isbnInformationList = isbnInformationService.findAll(refKeyList);
			for (IsbnInformation isbnInformation : isbnInformationList) {
				map.put(isbnInformation.getId(), helpMap.get(isbnInformation.getBarcode()));
			}
			return map;
			
		}
		return map;
	}
	
	/**
	 * 分发完成改变isbnManage status
	 * 
	 * @param isbnManage
	 * @param type
	 */
	private void distributedChangeStatus(IsbnManage isbnManage,int type) {
		isbnManage.setUpdateTs(new Date());
		isbnManage.setUpdateBy(getCurUserId());
		if (0 == type) {
			//购书
			isbnManage.setStatus(1);
		}else if (1 == type) {
			//上传图片并完善信息
			isbnManage.setStatus(2);
		}else if (2 == type) {
			//审核发布
			isbnManage.setStatus(3);
		}
	}
	
	private Long getCurUserId(){
		try {
			Long curUserId = SecurityContext.getInstance().getCurrentUserId();
			return curUserId==null?ISBN_ADMIN_USERID:curUserId;
		} catch (Exception e) {
			return ISBN_ADMIN_USERID;
		}
		
	}
	
	/**
	 * 单条记录分发
	 * 
	 * @param distributeFrom
	 * @param distributeTo
	 * @param comments
	 * @param type	isbnDistribute type
	 * 				0:购书任务       对应refKey       isbn_manage id
					1:上传图片并完善信息        对应refKey       isbn_information   id
					2,并审核发布    对应refKey      isbn_information   id
	 * @param refKey
	 * @return
	 */
	@Override
	@Transactional
	public boolean distributeOne(Long distributeFrom,Long distributeTo,String comments
			,int type ,Long refKey){
		if (distributeTo == null || refKey == null || distributeFrom == null) {
			return false;
		}
		List<Long> exsitRefKeyList = isbnAutoDistributeRepository.getExsitRefKey(type, Arrays.asList(refKey));
		if (CollectionUtils.isNotEmpty(exsitRefKeyList)) {
			return true;
		}
		Map<Long, IsbnManage> isbnManageMap = getIsbnManageMap(type,Arrays.asList(refKey));
		IsbnManage isbnManage = isbnManageMap.get(refKey);
		if (isbnManage == null) {
			return false;
		}
		IsbnDistribute isbnDistribute = new IsbnDistribute();
		isbnDistribute.setCreateTs(new Date());
		isbnDistribute.setCreateBy(getCurUserId());
		isbnDistribute.setType(type);
		isbnDistribute.setDistributeFrom(distributeFrom);
		isbnDistribute.setDistributeTo(distributeTo);
		isbnDistribute.setComments(comments);
		isbnDistribute.setRefKey(refKey);
		isbnDistribute.setStatus(0);
		isbnDistribute.setBarcode(isbnManage.getBarcode());
		isbnDistributeService.save(isbnDistribute);
		//按分发类型更改状态
		distributedChangeStatus(isbnManage,type);
		isbnManageService.save(isbnManage);
		return true;
	}
	
	/**
	 * 自动
	 * 单条记录分发
	 * 
	 * @param IsbnRoleCodeEnum
	 * @param refKey
	 * 					购书任务           isbn_manage id
	 * 					上传图片并完善信息            isbn_information   id
	 * 					并审核发布         isbn_information   id
	 * @return
	 */
	@Override
	@Transactional
	public boolean autoDistributeOne(IsbnRoleCodeEnum isbnRoleCodeEnum,Long refKey){
		if (isbnRoleCodeEnum == null || refKey == null) {
			return false;
		}
		int type = isbnRoleCodeEnum.getType();
		Long roleId = getRoleId(isbnRoleCodeEnum);
		Long distributeTo = getAutoUserId(roleId,type,getIsbnManagerRoleId());
		String comments = "自动分发";
		return distributeOne(getCurUserId(), distributeTo, comments, type, refKey);
	}
	
	/**
	 * 多条记录分发
	 * 
	 * @param distributeFrom
	 * @param distributeTo
	 * @param comments
	 * @param type	isbnDistribute type
	 * 				0:购书任务       对应refKeyList       isbn_manage id
					1:上传图片并完善信息        对应refKeyList       isbn_information   id
					2,并审核发布    对应refKeyList       isbn_information   id
	 * @param refKeyList
	 * @return
	 */
	@Override
	@Transactional
	public boolean distributeMuti(Long distributeFrom,Long distributeTo,String comments
			,int type ,List<Long> refKeyList){
		if (distributeTo == null || CollectionUtils.isEmpty(refKeyList) || distributeFrom == null) {
			return false;
		}
		List<IsbnDistribute> list = new ArrayList<IsbnDistribute>();
		List<Long> exsitRefKeyList = isbnAutoDistributeRepository.getExsitRefKey(type, refKeyList);
		Map<Long, IsbnManage> isbnManageMap = getIsbnManageMap(type,refKeyList);
		List<IsbnManage> isbnManageList = new ArrayList<IsbnManage>();
		for (Long refKey : refKeyList) {
			IsbnManage isbnManage = isbnManageMap.get(refKey);
			if (exsitRefKeyList.contains(refKey) || isbnManage == null) {
				continue;
			}
			IsbnDistribute isbnDistribute = new IsbnDistribute();
			isbnDistribute.setCreateTs(new Date());
			isbnDistribute.setCreateBy(getCurUserId());
			isbnDistribute.setType(type);
			isbnDistribute.setDistributeFrom(distributeFrom);
			isbnDistribute.setDistributeTo(distributeTo);
			isbnDistribute.setComments(comments);
			isbnDistribute.setRefKey(refKey);
			isbnDistribute.setStatus(0);
			isbnDistribute.setBarcode(isbnManage.getBarcode());
			
			list.add(isbnDistribute);
			//按分发类型更改状态
			distributedChangeStatus(isbnManage,type);
			isbnManageList.add(isbnManage);
			
			//避免同一批重复分发
			exsitRefKeyList.add(refKey);
			
		}
		if (CollectionUtils.isNotEmpty(list)) {
			isbnDistributeService.save(list);
			//分发完毕更新状态
			isbnManageService.save(isbnManageList);
		}
		return true;
	}
	

	/**
	 * 自动
	 * 多条记录分发
	 * 
	 * @param IsbnRoleCodeEnum
	 * @param refKeyList
	 * 					购书任务           isbn_manage id
	 * 					上传图片并完善信息            isbn_information   id
	 * 					并审核发布         isbn_information   id
	 * @return
	 */
	@Override
	@Transactional
	public boolean autoDistributeMuti(IsbnRoleCodeEnum isbnRoleCodeEnum,List<Long> refKeyList){
		if (isbnRoleCodeEnum == null || CollectionUtils.isEmpty(refKeyList)) {
			return false;
		}
		Long roleId = getRoleId(isbnRoleCodeEnum);
		int type = isbnRoleCodeEnum.getType();
		String comments = "自动分发";
		Long distributeTo = null;
		List<Long> keyList = new ArrayList<Long>();
		for (int i = 0; i < refKeyList.size(); i++) {
			keyList.add(refKeyList.get(i));
			if (keyList.size()%ONCE_AUTO_DISTRIBUTE_COUNT == 0) {
				distributeTo = getAutoUserId(roleId,type,getIsbnManagerRoleId());
				distributeMuti(getCurUserId(), distributeTo, comments, type, keyList);
				keyList.clear();
			}
		}
		if (CollectionUtils.isNotEmpty(keyList)) {
			distributeTo = getAutoUserId(roleId,type,getIsbnManagerRoleId());
			distributeMuti(getCurUserId(), distributeTo, comments, type, keyList);
		}
		return true;
		
	}

}
